package com.health_predict_springboot.utils;

import java.util.Collection;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串工具类，提供字符串处理、验证、转换等功能
 */
public class StringUtils {

    /**
     * 检查字符串是否为空
     * @param str 要检查的字符串
     * @return 如果字符串为null或空，则返回true；否则返回false
     */
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    /**
     * 检查字符串是否不为空
     * @param str 要检查的字符串
     * @return 如果字符串不为null且不为空，则返回true；否则返回false
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 检查对象是否为空
     * @param obj 要检查的对象
     * @return 如果对象为null或空集合/数组/字符串，则返回true；否则返回false
     */
    @SuppressWarnings("rawtypes")
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        if (obj instanceof String) {
            return isEmpty((String) obj);
        }
        if (obj instanceof Collection) {
            return ((Collection) obj).isEmpty();
        }
        if (obj instanceof Map) {
            return ((Map) obj).isEmpty();
        }
        if (obj.getClass().isArray()) {
            return java.lang.reflect.Array.getLength(obj) == 0;
        }
        return false;
    }

    /**
     * 检查对象是否不为空
     * @param obj 要检查的对象
     * @return 如果对象不为null且不为空集合/数组/字符串，则返回true；否则返回false
     */
    public static boolean isNotEmpty(Object obj) {
        return !isEmpty(obj);
    }

    /**
     * 检查字符串是否为纯数字
     * @param str 要检查的字符串
     * @return 如果字符串为纯数字，则返回true；否则返回false
     */
    public static boolean isNumeric(String str) {
        if (isEmpty(str)) {
            return false;
        }
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 检查字符串是否为有效的手机号码
     * @param phone 要检查的手机号码
     * @return 如果是有效的手机号码，则返回true；否则返回false
     */
    public static boolean isPhone(String phone) {
        if (isEmpty(phone)) {
            return false;
        }
        // 简单的手机号正则表达式，匹配11位数字，以1开头
        String regex = "^1[3-9]\\d{9}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(phone);
        return matcher.matches();
    }

    /**
     * 检查字符串是否为有效的邮箱地址
     * @param email 要检查的邮箱地址
     * @return 如果是有效的邮箱地址，则返回true；否则返回false
     */
    public static boolean isEmail(String email) {
        if (isEmpty(email)) {
            return false;
        }
        // 简单的邮箱正则表达式
        String regex = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(email);
        return matcher.matches();
    }

    /**
     * 检查字符串是否为有效的身份证号码
     * @param idCard 要检查的身份证号码
     * @return 如果是有效的身份证号码，则返回true；否则返回false
     */
    public static boolean isIdCard(String idCard) {
        if (isEmpty(idCard)) {
            return false;
        }
        // 简单的身份证正则表达式，匹配15位或18位
        String regex = "(^\\d{15}$)|(^\\d{18}$)|(^\\d{17}(\\d|X|x)$)";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(idCard);
        return matcher.matches();
    }

    /**
     * 截取字符串，如果长度超过指定值，则截取并添加省略号
     * @param str 原始字符串
     * @param maxLength 最大长度
     * @return 处理后的字符串
     */
    public static String truncate(String str, int maxLength) {
        if (isEmpty(str) || str.length() <= maxLength) {
            return str;
        }
        return str.substring(0, maxLength) + "...";
    }

    /**
     * 首字母大写
     * @param str 原始字符串
     * @return 首字母大写后的字符串
     */
    public static String firstLetterToUpperCase(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    }

    /**
     * 首字母小写
     * @param str 原始字符串
     * @return 首字母小写后的字符串
     */
    public static String firstLetterToLowerCase(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return Character.toLowerCase(str.charAt(0)) + str.substring(1);
    }

    /**
     * 将下划线命名转换为驼峰命名
     * @param str 下划线命名字符串
     * @return 驼峰命名字符串
     */
    public static String underScoreToCamelCase(String str) {
        if (isEmpty(str)) {
            return str;
        }
        StringBuilder result = new StringBuilder();
        boolean nextUpperCase = false;
        for (int i = 0; i < str.length(); i++) {
            char currentChar = str.charAt(i);
            if (currentChar == '_') {
                nextUpperCase = true;
            } else {
                if (nextUpperCase) {
                    result.append(Character.toUpperCase(currentChar));
                    nextUpperCase = false;
                } else {
                    result.append(currentChar);
                }
            }
        }
        return result.toString();
    }

    /**
     * 将驼峰命名转换为下划线命名
     * @param str 驼峰命名字符串
     * @return 下划线命名字符串
     */
    public static String camelCaseToUnderScore(String str) {
        if (isEmpty(str)) {
            return str;
        }
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char currentChar = str.charAt(i);
            if (Character.isUpperCase(currentChar) && i > 0) {
                result.append('_');
                result.append(Character.toLowerCase(currentChar));
            } else {
                result.append(Character.toLowerCase(currentChar));
            }
        }
        return result.toString();
    }

    /**
     * 去除字符串两端的空白字符
     * @param str 原始字符串
     * @return 去除空白后的字符串
     */
    public static String trim(String str) {
        if (str == null) {
            return null;
        }
        return str.trim();
    }

    /**
     * 去除字符串中的所有空白字符
     * @param str 原始字符串
     * @return 去除所有空白后的字符串
     */
    public static String removeAllSpaces(String str) {
        if (str == null) {
            return null;
        }
        return str.replaceAll("\\s+", "");
    }

    /**
     * 重复字符串指定次数
     * @param str 要重复的字符串
     * @param times 重复次数
     * @return 重复后的字符串
     */
    public static String repeat(String str, int times) {
        if (str == null || times <= 0) {
            return "";
        }
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < times; i++) {
            result.append(str);
        }
        return result.toString();
    }

    /**
     * 安全地比较两个字符串是否相等，处理null值
     * @param str1 第一个字符串
     * @param str2 第二个字符串
     * @return 如果两个字符串相等，则返回true；否则返回false
     */
    public static boolean equals(String str1, String str2) {
        if (str1 == str2) {
            return true;
        }
        if (str1 == null || str2 == null) {
            return false;
        }
        return str1.equals(str2);
    }

    /**
     * 安全地比较两个字符串是否相等（忽略大小写），处理null值
     * @param str1 第一个字符串
     * @param str2 第二个字符串
     * @return 如果两个字符串相等（忽略大小写），则返回true；否则返回false
     */
    public static boolean equalsIgnoreCase(String str1, String str2) {
        if (str1 == str2) {
            return true;
        }
        if (str1 == null || str2 == null) {
            return false;
        }
        return str1.equalsIgnoreCase(str2);
    }
}